/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package fi.uba.algo3.tp3.utils.dijkstra.builder;


import fi.uba.algo3.tp3.utils.Punto;
import fi.uba.algo3.tp3.utils.dijkstra.Camino;
import fi.uba.algo3.tp3.utils.dijkstra.DijkstraGraph;
import fi.uba.algo3.tp3.utils.dijkstra.Vertice;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import org.json.me.JSONArray;
import org.json.me.JSONException;
import org.json.me.JSONObject;


/**
 *
 * @author Kimi
 */
public class GraphLoader {

    private String filePath;
    private DijkstraGraph graph;
    private int bloqueAncho;
    private int bloqueAlto;

    public GraphLoader(String filePath) {
        this.filePath = filePath;
    }


    public DijkstraGraph loadGraphFromJSONFile() {
        try {
            HashMap<Punto,Vertice> mapPuntoVertice;
            mapPuntoVertice = new HashMap<Punto, Vertice>();

            graph = new DijkstraGraph();

            String fileContent = readFile();
            JSONObject jObject = new JSONObject(fileContent);

  //          System.out.println("graph Type: " + jObject.getString("type"));

            bloqueAlto = jObject.getInt("bloqueAlto");

            bloqueAncho =jObject.getInt("bloqueAncho");


            // obtengo los vertices, y los creo.
            JSONArray vertices = jObject.getJSONArray("vertices");
            for (int i = 0; i < vertices.length(); i++) {
                int x = 0,y = 0;
                
                JSONObject verticeJSON = vertices.getJSONObject(i);
                
                x = verticeJSON.getInt("x");
                y = verticeJSON.getInt("y");

                x = (x*bloqueAncho)+(bloqueAncho/2);
                y = (y*bloqueAlto)+(bloqueAlto/2);

                Punto p = new Punto(x, y);

                //Punto p = new Punto(x, y);
                Vertice vertice = new Vertice(p);

           //     System.out.println("Punto " + p.getX() + ";" + p.getY());

                mapPuntoVertice.put(p, vertice);

                graph.addVertice(vertice);
            }

            JSONObject jaulaJSON = jObject.getJSONObject("jaula");
            int jaulaX = jaulaJSON.getInt("x");
            int jaulaY = jaulaJSON.getInt("y");

            Punto jaulaPunto = new Punto(jaulaX, jaulaY);
            Vertice puertaJaula = new Vertice(jaulaPunto);                 
            mapPuntoVertice.put(jaulaPunto, puertaJaula);
            graph.addVertice(puertaJaula);

            int caminosCreados = 0;

            // los caminos no los levanto del archivo, sino que los creo
            // no se permiten caminos en diagonal
            for (Vertice vertice : mapPuntoVertice.values()) {

                Punto puntoActual = vertice.getPunto();

                // hay cuatro direcciones posibles
                // intento obtener vertices segun el punto cercano

    //            System.out.println("Punto Actual es " + puntoActual.getX() + ";" + puntoActual.getY());

                int xDelta = bloqueAncho;
                int yDelta = bloqueAlto;

                // a los laterales
                Punto p1 = new Punto(puntoActual.getX()-xDelta,puntoActual.getY());
                Punto p2 = new Punto(puntoActual.getX()+xDelta,puntoActual.getY());

                Punto p3 = new Punto(puntoActual.getX(),puntoActual.getY()-yDelta);
                Punto p4 = new Punto(puntoActual.getX(),puntoActual.getY()+yDelta);

                Punto[] pArray = new Punto[] {p1,p2,p3,p4};

                for (int i = 0; i < pArray.length; i++) {

                    Vertice otroVertice = mapPuntoVertice.get(pArray[i]);

                    if (otroVertice != null) {
                        // camino posible
                        Camino camino = new Camino(otroVertice, 1.0);
/*
                        System.out.println("Camino de (" + puntoActual.getX()+";"+puntoActual.getY()+
                                ") hacia (" + otroVertice.getPunto().getX() + ";"+
                                otroVertice.getPunto().getY() + ")");
*/

                        vertice.agregarCamino(camino);
                        caminosCreados++;
                    }
                }
            }                      

  //          System.out.println("Caminos creados " + caminosCreados);

        } catch (JSONException ex) {
            ex.printStackTrace();
            graph = null;
        }
        return graph;
    }

    private String readFile() {
        String content = "";
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(filePath);
            // Here BufferedInputStream is added for fast reading.
            BufferedInputStream bis = new BufferedInputStream(fis);

            BufferedReader br = new BufferedReader(new InputStreamReader(bis));

            String line = br.readLine();
            while (line != null) {
                content +=line + "\r\n";
                line = br.readLine();
            }

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        return content;
    }
}
